Before the availability of the personal computer (PC), computer graphics packages were expensive tools primarily reserved for industrial applications. Early microcomputers were only capable of rendering simple line drawings with a low screen resolution (256.times.256, for example).
As microcomputers evolved, higher resolution color displays became available, and software applications routinely provided data output in a graphical manner. Objects typically were defined in terms of absolute coordinates using straight lines. Subsequently, graphics "primitives" were used, enabling circles, ellipses, rectangles and polygons to be drawn with a single instruction. The use of primitives that can be rendered with a single instruction set of parameters has increased the speed at which the images can be rendered.
The availability of computer graphics has generated a demand for higher resolutions and three dimensional (3-D) rendering capabilities. Computer animation and games, in particular, have driven a demand for even greater graphics capabilities. A 3-D image can be represented in a computer system as a collection of graphical objects, such as polygons, lines, and points. A set of vertex points defines a polygon. Associated with each point are certain pixel values, such as shading, texturing, color, and the like. Identification of other points within the polygon typically is done through the use of linear interpolation. Once interpolated, the polygon can be rendered on a computer monitor by successive scanning of orthogonal rows of the polygon.
Even with more sophisticated graphics packages, developing animation applications can be a tedious and time consuming process. Moreover, the more detailed the graphics application, the greater the work required to produce the graphics. To reduce the amount of work required, programmers often repeat images in the animation. Graphics packages have been developed which facilitate the use of previous graphics data. In particular, the use of bit block transfers (BitBLT's) have become common as a vehicle to quickly and easily modify previous graphics data to obtain new graphics data arrays. During a BitBLT operation, display data stored in the frame buffer or in host memory is used as source data to generate an image destined for display. Thus, a source array of pixels in the frame buffer or host memory is used to generate a destination array of pixels in the frame buffer for display on the display device. As one skilled in the art will understand, other bit block transfers also are possible, such as replacing a destination array of pixels with a pixel-by-pixel combination of the destination array and data from a pattern.
Various BitBLT's have become standard in the graphics industry for quickly and efficiently generating an image to obtain a destination image for display. Examples of some common BitBLT operations include resize and transparency BitBLT's. The use of these and other BitBLT's enables previously used images to be used in some fashion to more quickly render a new image. Thus, for example, the resize BitBLT permits the size of a previously used image to be either enlarged (a stretch BitBLT) or reduced (a shrink BitBLT), as desired to fit the needs of the graphics application. It may desirable, for example, to shrink or stretch an image to show relative distance to an object. Stretch BitBLT operations are performed by interpolating an existing image, while shrink BitBLT's are obtained by averaging or decimating pixel values in an image. Thus, for example, in a stretch operation four pixels may be used to represent what previously was one pixel. Conversely, in a shrink operation, one pixel may be used to represent what previously was shown in four pixels.
Another desirable BitBLT operation is one which permits use of a portion of a previous image, which may be implemented through a transparency BitBLT. Thus, an object moving through a scene may be repeatedly re-used in subsequent scenes by making transparent the background around the object, permitting the object to be overlaid on a different background. For example, a car passing in front of a row of stores may be repeatedly re-used by making transparent the background around the car, and then moving the car (with the masked background) to various destinations on the screen.
BitBLT's normally are transferred in rectangular pixel blocks to simplify the logic and to avoid the need to precisely define the edge of a complex object. Performing a transparent BitBLT on an object within the rectangular image is achieved by placing the desired object on a constant color (or pattern) background and essentially lifting the object off of the background through the use of a color (or pattern) comparison operation. Thus, an object on a blue background can be copied to the destination region of the screen by transferring a rectangular pixel array including the object and blue background. The blue background then is detected by color comparisons and made transparent. Preferably, a transparency bit is provided or embedded with each pixel value in the image to indicate whether the pixel value is to be transparent or displayed. In this fashion, images may be copied to a destination location, with only the desired object displayed, based upon the status of the embedded transparency pixel value. Thus, the blue background pixels are compared and the transparency bit enabled (based on color range of blue) so that during a transparency BitBLT operation the blue background in the destination array may be made transparent, while the desired object is displayed.
In certain instances, it may be advantageous to perform a transparency bit block transfer on an object, while also resizing the object. A problem arises, however, when a resize BitBLT is combined with a transparency BitBLT because of the fact that the transparency enable bit is lost during resizing operations. Take, for example, an image with sixty-four pixels, twenty of which are transparency enabled. If the image is reduced from sixty-four to sixteen pixels, there is no clear technique available to maintain the integrity of the transparency bit embedded in the image. As a result, the transparency bit value must either be disregarded or the subject of error. Without the use of the embedded transparency bit, there is no quick method for performing the transparency BitBLT.
In addition, it has become increasingly desirable to use video data as an input to graphics applications. Video signals (referred to as YUV), however, must be converted to graphics signals (referred to as RGB) for displaying on conventional personal computer (PC) graphics systems. In many instances, the conversion takes a relatively large amount of time. The video data typically must be scaled, filtered and converted to an RGB value. In addition, if desired for texture mapping, the data also then must be color compared. It would be advantageous if a bit block transfer operation was available that was capable of performing the data manipulation of the video data in a single process.